home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung 2 / Power-Programmierung CD 2 (Tewi)(1994).iso / c / library / dos / diverses / leda / incl / p_dictio.h < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-15  |  5.5 KB  |  164 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  2.1.1                                                 11-15-1991
  4. +
  5. +
  6. +  p_dictionary.h
  7. +
  8. +
  9. +  Copyright (c) 1991  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16.  
  17.  
  18. #ifndef P_DICTIONARY_H
  19. #define P_DICTIONARY_H
  20.  
  21. #include <LEDA/pers_tree.h>
  22.  
  23.  
  24. typedef NODE* p_dic_item;
  25.  
  26.  
  27. #define PERS_DIC(keytype,infotype) name3(keytype,infotype,PERS_DIC)
  28.  
  29. #define p_dictionary(keytype,infotype) name3(keytype,infotype,p_dictionary)
  30.  
  31. #define p_dictionarydeclare2(keytype,infotype)\
  32. \
  33. struct PERS_DIC(keytype,infotype): public pers_rb_tree{\
  34. \
  35. void copy_key(ent& x)         { Copy(*(keytype*)&x); }\
  36. void copy_inf(ent& x)         { Copy(*(infotype*)&x); }\
  37. void clear_key(ent& x)        { Clear(*(keytype*)&x); }\
  38. void clear_inf(ent& x)        { Clear(*(infotype*)&x); }\
  39. void print_key(ent& x)        { Print(*(keytype*)&x); }\
  40. int  cmp_keys(ent& x, ent& y) { return compare(*(keytype*)&x, *(keytype*)&y); }\
  41. \
  42. version V;\
  43. int count;\
  44. \
  45. public:\
  46. \
  47.  PERS_DIC(keytype,infotype)() { init_tree(); V = v_list->vl.first(); count=1;}\
  48.  PERS_DIC(keytype,infotype)(V_LIST* vl,version v) { v_list=vl; V=v; count=1;}\
  49.  void CLEAR() { if (--v_list->count==0) del_tree(); }\
  50. ~PERS_DIC(keytype,infotype)() { CLEAR(); }\
  51. \
  52. PERS_DIC(keytype,infotype)(PERS_DIC(keytype,infotype)& D)\
  53. { v_list = D.v_list; v_list->count++; V = D.V; count = D.count; }\
  54. \
  55. PERS_DIC(keytype,infotype)& operator=(PERS_DIC(keytype,infotype)& D)\
  56. { CLEAR(); v_list = D.v_list; v_list->count++; V = D.V; count = D.count;\
  57.   return *this; }\
  58. \
  59. keytype  key(NODE* p)  { return keytype(pers_rb_tree::key(p)); }\
  60. infotype inf(NODE* p)  { return infotype(pers_rb_tree::inf(p)); }\
  61. \
  62. NODE* locate(keytype k) { return pers_rb_tree::locate(Ent(k),V); }\
  63. NODE* locate_pred(keytype k) { return pers_rb_tree::locate_pred(Ent(k),V); }\
  64. NODE* lookup(keytype k) { return pers_rb_tree::lookup(Ent(k),V); }\
  65. \
  66. PERS_DIC(keytype,infotype)  insert(keytype k, infotype i)\
  67. { return PERS_DIC(keytype,infotype)(v_list,pers_rb_tree::insert(Ent(k),Ent(i),V)); }\
  68. \
  69. PERS_DIC(keytype,infotype)  del(keytype k)\
  70. { return PERS_DIC(keytype,infotype)(v_list,pers_rb_tree::del(Ent(k),V)); }\
  71. \
  72. PERS_DIC(keytype,infotype)  change_inf(NODE* p, infotype i)\
  73. { return PERS_DIC(keytype,infotype)(v_list,pers_rb_tree::change_inf(p,Ent(i),V)); }\
  74. \
  75. NODE* min()          { return pers_rb_tree::min(V); }\
  76. NODE* max()          { return pers_rb_tree::max(V); }\
  77. NODE* succ(NODE* p)  { return pers_rb_tree::succ(p,V); }\
  78. NODE* pred(NODE* p)  { return pers_rb_tree::pred(p,V); }\
  79. int   size()         { return pers_rb_tree::size(V); }\
  80. void  print()        { pers_rb_tree::print(V); }\
  81. void  draw(DRAW_NODE_FCT f, DRAW_EDGE_FCT g, double x0, double x1, double y, double dy)  { pers_rb_tree::draw(f,g,V,x0,x1,y,dy); }\
  82. double get_version() { return ver_num(V); }\
  83. \
  84. };\
  85. \
  86. class p_dictionary(keytype,infotype){\
  87. \
  88. PERS_DIC(keytype,infotype)* ptr;\
  89. \
  90. public:\
  91. \
  92. p_dictionary(keytype,infotype)()      { ptr = new PERS_DIC(keytype,infotype); }\
  93. p_dictionary(keytype,infotype)(int)   { ptr = new PERS_DIC(keytype,infotype); }\
  94. p_dictionary(keytype,infotype)(PERS_DIC(keytype,infotype)* p)\
  95. { ptr = (PERS_DIC(keytype,infotype)*)p; }\
  96. \
  97. p_dictionary(keytype,infotype)(ent p)\
  98. { ptr = (PERS_DIC(keytype,infotype)*)p; ptr->count++;}\
  99. \
  100. void clear() { if (--(ptr->count) == 0) delete ptr; }\
  101. \
  102. ~p_dictionary(keytype,infotype)()     { clear(); }\
  103. \
  104. \
  105. p_dictionary(keytype,infotype)(p_dictionary(keytype,infotype)& p)\
  106. { ptr = p.ptr; ptr->count++; }\
  107. \
  108. p_dictionary(keytype,infotype)& operator=(const p_dictionary(keytype,infotype)& p)\
  109. { p.ptr->count++;\
  110.   if (--ptr->count == 0)  delete ptr;\
  111.   ptr = p.ptr;\
  112.   return *this;\
  113. }\
  114. \
  115. keytype  key(NODE* p)     { return ptr->key(p); }\
  116. infotype inf(NODE* p)     { return ptr->inf(p); }\
  117. \
  118. NODE* locate(keytype k)      { return ptr->locate(k); }\
  119. NODE* locate_pred(keytype k) { return ptr->locate_pred(k); }\
  120. NODE* lookup(keytype k)      { return ptr->lookup(k); }\
  121. \
  122. p_dictionary(keytype,infotype) insert(keytype k, infotype i)\
  123. { return new PERS_DIC(keytype,infotype)(ptr->insert(k,i)); }\
  124. \
  125. p_dictionary(keytype,infotype) del(keytype k)\
  126. { return new PERS_DIC(keytype,infotype)(ptr->del(k)); }\
  127. \
  128. p_dictionary(keytype,infotype) change_inf(NODE* p, infotype i)\
  129. { return new PERS_DIC(keytype,infotype)(ptr->change_inf(p,i)); }\
  130. \
  131. int ref() { return ptr->count; }\
  132. \
  133. NODE* min()         { return ptr->min();     }\
  134. NODE* max()         { return ptr->max();     }\
  135. \
  136. NODE* succ(NODE* p)   { return ptr->succ(p);   }\
  137. NODE* succ(keytype k) { return locate(k); }\
  138. NODE* pred(NODE* p)   { return ptr->pred(p);   }\
  139. NODE* pred(keytype k) { return locate_pred(k); }\
  140. \
  141. NODE* first_item()       { return ptr->min();     }\
  142. NODE* next_item(NODE* p) { return ptr->succ(p);   }\
  143. \
  144. int   size()        { return ptr->size();    }\
  145. int   empty()       { return ptr->size()==0; }\
  146. \
  147. void  print()       { ptr->print(); }\
  148. void  draw(DRAW_NODE_FCT f, DRAW_EDGE_FCT g, double x0, double x1, double y, double dy)  { ptr->draw(f,g,x0,x1,y,dy); }\
  149. \
  150. friend ent  Copy(const p_dictionary(keytype,infotype)& D)\
  151. { D.ptr->count++; return ent(D.ptr); }\
  152. \
  153. friend ent  Ent(const p_dictionary(keytype,infotype)& D) { return D.ptr; }\
  154. \
  155. friend void Clear(p_dictionary(keytype,infotype)& D)     { D.clear(); }\
  156. \
  157. friend void Print(const p_dictionary(keytype,infotype)&, ostream& = cout) { }\
  158. \
  159. friend void Read(const p_dictionary(keytype,infotype)&, istream& = cin) { }\
  160. }; 
  161.  
  162.  
  163. #endif
  164.